Closes #22587: Implement Divergence Checking for Match Types

Note to Reviewers: I have rebased this branch on top of PR #24743 to resolve CI failures caused by the typeSize bug. As a result, the commit from that PR currently appears in this branch's history. Once PR #24743 is accepted and merged into main, that extra commit will automatically be skipped or dropped from this PR during the final merge process.

This pull request closes #22587 by implementing a robust divergence checking mechanism for Match Types. Currently, the compiler relies on catching StackOverflowError to handle infinite recursion during match type reduction, which is an unsafe and inefficient approach. This PR replaces that behavior by adapting the "Open Implicits" divergence checking algorithm (from SIP-31) specifically for AppliedTypes and MatchTypes.

To achieve this, I have introduced a new Property in the Context to track the history of types currently being reduced. The algorithm enforces termination by verifying that the size of the match type arguments decreases according to a lexicographical ordering. In cases where the size remains constant across a reduction step, the algorithm utilizes the history memory to verify that the Match Type arguments have not been encountered before (detecting cycles).

1. Allowed: Decreasing Size Recursive types are permitted if the argument size strictly decreases.

type Unwrap[X] = X match
  case Option[t] => Unwrap[t]
  case _ => X

In this example, reducing Unwrap[Option[Option[Int]]] is allowed because the argument shrinks from Option[Option[Int]] to Option[Int].

2. Allowed: Same Size (Non-Cyclic) State machines or traversals are permitted if the size remains constant, provided the exact state is not repeated.

type Increase[X, Y, Z] = (X, Y, Z) match
  case (X, Y, 0) => Increase[X, Y, 1]
  case (X, 0, _) => Increase[X, 1, 0]
  case (0, _, _) => Increase[1, 0, 0]
  case _ => "done"

Here, Increase[0,0,0] passes through all binary combinations. The algorithm permits this because, although the type size remains constant, no specific tuple combination is repeated in the history.

3. Disallowed: Increasing Size or Cycles The algorithm correctly rejects divergence caused by growing types:

// Rejected: Argument grows (Int -> List[Int])
type Wrap[X] = X match
  case AnyVal => Wrap[List[X]]
  case AnyRef => Wrap[List[X]]

And rejects divergence caused by loops (same size, same state):

// Rejected: Cyclic reference detected (Int -> ... -> Int)
type Loop[X] = X match
  case Int => Loop[Float]
  case Float => Loop[Double]
  case Double => Loop[String]
  case String => Loop[Int]
  case _ => String